﻿#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>

using namespace std;
// 1.请设计一个类，不能被拷贝
class NonCopyableBase {
protected:
    NonCopyableBase() = default;
    ~NonCopyableBase() = default;

    NonCopyableBase(const NonCopyableBase&) = delete;
    NonCopyableBase& operator=(const NonCopyableBase&) = delete;
};

class MyClass : private NonCopyableBase {
    // 这个类现在不能被拷贝
    // 可以添加其他成员函数和数据成员
};

// 2. 请设计一个类，只能在堆上创建对象
class HeapOnly {
public:
    // 静态创建方法
    static HeapOnly* create() {
        return new HeapOnly();
    }

    // 必须提供销毁方法
    void destroy() {
        delete this;
    }

private:
    // 私有构造函数
    HeapOnly() = default;

    // 私有析构函数
    ~HeapOnly() = default;

    // 防止拷贝
    HeapOnly(const HeapOnly&) = delete;
    HeapOnly& operator=(const HeapOnly&) = delete;
};

// 3. 请设计一个类，只能在栈上创建对象v
// 方法一：重载并禁用 operator new 和 operator delete
//class StackOnly {
//public:
//    StackOnly() = default;
//    ~StackOnly() = default;
//
//    // 禁用堆上分配
//    static void* operator new(std::size_t) = delete;
//    static void* operator new[](std::size_t) = delete;
//
//    // 禁用堆上释放
//    static void operator delete(void*) = delete;
//    static void operator delete[](void*) = delete;
//
//    // 防止拷贝（可选）
//    StackOnly(const StackOnly&) = delete;
//    StackOnly& operator=(const StackOnly&) = delete;
//};
// 
// 方法二：私有化 operator new 和 operator delete（传统C++方法）
class StackOnly {
public:
    StackOnly() = default;
    ~StackOnly() = default;

private:
    // 私有化堆分配函数
    static void* operator new(std::size_t);
    static void* operator new[](std::size_t);

    // 私有化堆释放函数
    static void operator delete(void*);
    static void operator delete[](void*);
};

// 4. 请设计一个类，不能被继承
class NonInheritable final {
public:
    NonInheritable() = default;
    ~NonInheritable() = default;

    // 其他成员函数...
};

// 5. 请设计一个类，只能创建一个对象(单例模式)
// 饿汉模式（线程安全，启动时即创建）
//class Singleton
//{
//public:
//    //删除拷贝构造函数和赋值运算符
//    Singleton(const Singleton&) = delete;
//    Singleton& operator = (const Singleton& ) = delete;
//
//    //获取单例
//    static Singleton& getInstance()
//    {
//        return instance;
//    }
//
//    //其他成员函数...
//    void other()
//    {}
//
//private:
//    //私有构造函数
//    Singleton() = default;
//
//    //私有析构函数
//    ~Singleton() = default;
//
//    //静态实例
//    static Singleton instance;
//};
//// 在类外初始化静态成员
//Singleton Singleton::instance;

// 懒汉模式（线程不安全，基础版）
class Singleton {
public:
    // 删除拷贝构造函数和赋值运算符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    // 获取单例实例
    static Singleton& getInstance() {
        static Singleton instance;  // C++11保证局部静态变量线程安全
        return instance;
    }

    // 其他成员函数...
    void doSomething() { /*...*/ }

private:
    // 私有构造函数
    Singleton() = default;

    // 私有析构函数
    ~Singleton() = default;
};

int main()
{

	return 0;
}